package com.ftg.learn.chapter07;

import java.util.Scanner;

/**
 * 学习数组
 * @author kangjx
 * @createTime 2022/7/15
 */
public class LearnArray {

//    数组元素的类型[] 数组引用变量 = new 数组元素的类型[元素个数];

    public void initArray(){
        byte a = 12;
        byte b = 13;
        byte[] bytes = new byte[2];
        bytes[0] = a;
        bytes[1] = b;
        bytes[2] = 34;

        //ArrayIndexOutOfBoundsException见名之义 数组下标越界
      //java.lang.ArrayIndexOutOfBoundsException: 2 异常
        System.out.println(bytes[1]);
//        数组引用变量[下标]  索引 index : 下标 0 正整数
    }

    public void initArray1(){
        int[] as = new int[100];
        for(int i = 0;i < 100;i++){
            as[i] = (i+1) % 2 ==0 ?i+1:-1;
        }

        for(int i = 0;i < 100;i++){
            System.out.println(as[i]);
        }
    }

    /**
     * @param arr 一个你给我的数组，里面的整数是没有排序 23,1,2,3,7
     * @return
     */
    public int[] orderby(int[] arr){
        int[] as = new int[arr.length];
        for(int i = 0;i < arr.length;i++){
            int arrmax = arr[0];
            int indexj = 0;
            for(int j =1;j< arr.length;j++){
                if(arrmax < arr[j]){
                    arrmax =arr[j];
                    indexj = j;
                }
            }
            arr[indexj] = -1;
            as[i] = arrmax;
        }
        return as;
    }


    public int[] orderby1(int[] arr) {
       long begin = System.currentTimeMillis();
        System.out.println(begin+"==>begin");
        //冒泡排序
        for(int i = 0;i < arr.length-1;i++){
            for(int j = 0;j < arr.length-1-i;j++){
                if(arr[j] < arr[j+1]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        long end = System.currentTimeMillis();
        System.out.println(end+"==>end");
        System.out.println(end - begin);
        return arr;
    }

    public int[] orderby2(int[] arr) throws InterruptedException {
        //冒泡排序
        for(int i = 0;i < arr.length-1;i++){
            for(int j = 0;j < arr.length-1-i;j++){
                if(arr[j] < arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        return arr;
    }

    /**
     * 交互操作，完成数据里面两个下标内容
     * @param arr
     * @param x
     * @param y
     */
    public void swap(int[] arr,int x,int y){
        if(x >=0 && y >= 0 && x < arr.length&& y < arr.length&& arr != null){
            int t = arr[x];
            arr[x] = arr[y];
            arr[y] = t;
        }
    }


//    6、猜价格，机器随机商品价格，用户输入价格，机器进行判断高低，直至猜对位置 整数
    public void q6(){

        int price = (int)(Math.random()*100) + 1;
        //scanner
        System.out.println(price);

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你猜的价格，区间[0-100]的正整数");
        while (true){
            int a = scanner.nextInt();
            if(a > price){
                System.out.println("猜大了");
                System.out.println("请再次输入你的价格");
            }else if(a < price){
                System.out.println("猜小了");
                System.out.println("请再次输入你的价格");
            }else{
                System.out.println("猜对了");
                break;
            }
        }

    }


    /**
     *  杀人游戏
     * @param personNo 共有多少犯人
     * @param x 隔几位一杀
     * @param y 活几人
     */
    public int[] killPlay(int personNo,int x,int y){

        //初始化犯人编号 1-10
        int[] t = initPersonNO(personNo);
        //所有被杀死的人的位置 12345689
        int[] dead = new int[personNo-y];

        int[] persons = initPersonNO(personNo);

        int n = 0;
        int kills = 0;
        int killed = 0;

        for(int i = 0,len = persons.length;i < len ;i++){
            if(persons[i] != -1){
                kills++;
            }
            if(kills == x){
                //表示被 杀了
                System.out.println(n);
                dead[n++] = persons[i];
                persons[i] = -1;
                kills = 0;
                killed++;
            }

            //循环到最后一人了
            if(i == len -1 && killed < personNo - y){
                i =  -1 ;
            }
        }

        //求差值
        return live(t,dead);
    }

    /**
     * 生成初始化的人员编号
     * @param personNo
     * @return
     */
    public int[] initPersonNO(int personNo){
//        if(personNo > 1){
//
//        }
        int[] ps = new int[personNo];
        for(int i = 0;i < personNo;i++){
            ps[i] = i + 1;
        }
        return ps;
    }

    /**
     *
     * @param x 所有人 [1,2,3] [2]
     * @param y 被杀死的人
     * @return
     */
    public int[] live(int[] x,int[] y){
        int[] ps = new int[Math.abs(y.length-x.length)];
        int a = 0;
        for(int i = 0;i < x.length;i++){
            boolean ist = false;
            for(int j = 0 ;j < y.length;j++){
                if(x[i] == y[j]){
                    ist=true;
                    break;
                }
            }
            if(ist == false){
                ps[a++] = x[i];
            }
        }
        return ps;
    }



    public static void main(String[] args) {
        LearnArray k = new LearnArray();
        k.q6();

    }

    /**
     * 二分法
     * @param as
     * @param target
     * @return
     */
    public boolean binarySearch(int[] as,int target){

        int low = 0;
        int upper = as.length - 1;
        boolean t = false;
        while (upper > low) {
            int middle = (upper + low) >> 1;
            if (as[middle] == target) {
                t = true;
                break;
            } else if (as[middle] > target) {
                upper = middle - 1;
            } else {
                low = middle + 1;
            }
        }
        return t;
    }

    //大哥
    public boolean equals(int[] as,int[] as1){

        if(as == as1) {
            return true;
        }
        if (as==null || as1==null) {
            return false;
        }
        if(as.length-as1.length != 0){
            return false;
        }

        for(int i = 0,len = as.length;i < len;i++){
            if(as[i] != as1[i]){
                return false;
            }
        }
//
//        if(as.length - as1.length == 0){
//            for(int i = 0,len = as.length;i < len;i++){
//                if(as[i] != as1[i]){
//                    ist = false;
//                    break;
//                }
//            }
//        }else{
//           ist = false;
//        }
        return true;
    }

    //求某一个数组里面最大的元素  可以使用外部变量
    //求某一个数组里面最大的元素  不可以使用外部变量
    // int a = 9; int b = 3; a = a + b; b = a - b; a = a - b;  a[0] = a[0]+ a[1]
}
